home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / docs / asm_guide / assembler course / 6.s < prev    next >
Text File  |  1992-04-27  |  4KB  |  135 lines
  1.  
  2. ; this is the same as 5, but a bit more structured.
  3.  
  4.  
  5. top:    movem.l    d0-d7/a0-a6,-(a7)    ; save regs on the stack.
  6.  
  7. loop:
  8.     clr.l    d0            ; move zeros to d0
  9.     bsr    checkleft        ; execute subroutines
  10.     bsr    checkright        ;    "        "
  11.     bsr    selectaction        ;    "        "
  12.  
  13.     cmp.l    #3,d0            ; d0 = 3 ?
  14.     bne.s    loop            ; not yet !!
  15.     
  16. endofprogram:
  17.  
  18.     movem.l    (a7)+,d0-d7/a0-a6    ; load the regs from stack
  19.     rts
  20.  
  21. ************************ subroutines ************************
  22.  
  23. checkleft:
  24.  
  25.     btst    #6,$bfe001        ; check left button
  26.     bne.s    endcheckleft        ; not pressed -> end checkl.
  27.  
  28.     add.l    #1,d0            ; pressed -> add 1 to d0
  29.  
  30. endcheckleft:
  31.  
  32.     rts                ; back to calling point
  33.  
  34. ; -------------------------------------
  35.  
  36. checkright:
  37.  
  38.     btst    #10,$dff016        ; this is how you check RMB
  39.     bne.s    endcheckright        ; not pressed -> end checkr.
  40.  
  41.     add.l    #2,d0            ; pressed -> add 2 to d0
  42.  
  43. endcheckright:
  44.  
  45.     rts                ; back to calling point
  46.  
  47. ; -------------------------------------
  48.  
  49. selectaction:
  50.  
  51.     cmp.l    #1,d0            ; d0 = 1 ?
  52.     bne.s    nobackgroundflash    ; no !
  53.  
  54.     add.w    #1,$dff180        ; yes !
  55.  
  56. nobackgroundflash:
  57.  
  58.     cmp.l    #2,d0            ; d0 = 2 ?
  59.     bne.s    notextflash        ; no !
  60.  
  61.     add.w    #1,$dff182        ; yes !
  62.  
  63. notextflash:
  64.  
  65.     rts
  66.  
  67. ; -------------------------------------
  68.  
  69. ; ok, this looks better ain't it ?  You see, the program has changed
  70. ; quite a bit:    we used 'SUBROUTINES'. Using them, you can
  71. ; put smaller problems (like checking the left- and the right button)
  72. ; in separate, smaller 'programs' and jump to it each time you need
  73. ; it. You will agree that it's easier to follow than example 5.
  74.  
  75. ; THERE'S ONE CONSEQUENCE WHEN USING SUBROUTINES: you must keep track
  76. ; of where you enter and leave the subroutine ! An example:
  77. ;
  78. ; You write a program that is intended to execute a subroutine, over
  79. ; and over again...
  80. ;
  81. ;    main:    BSR routine
  82. ;        BRA main
  83. ;
  84. ;    routine:instruction 1
  85. ;        instruction 2
  86. ;        ...
  87. ;        BRA main
  88. ;
  89. ; when you do a BSR, the computer saves this point in a list (called
  90. ; 'STACK'), so when he encounters a RTS, he can jump back to that
  91. ; point. This point will then be removed from the stack.
  92. ;    BSR (append this address to stack)
  93. ;    RTS (jump to current address in stack, remove stack-entry)
  94. ; If you do more BSR after eachother, he will store all these
  95. ; points, and the first RTS will cause him to jump back to the last
  96. ; saved point. Something like this :
  97. ;    BSR (save in stack, position 1)
  98. ;     BSR (save in stack, position 2)
  99. ;      ...
  100. ;     RTS (get position 2 from stack, remove it)
  101. ;    RTS (get position 1 from stack, remove it)
  102. ;    RTS (stack empty -> back to SEKA)
  103.  
  104. ; In our example, we never did a RTS, so the list would become larger
  105. ; and larger, After a while, memory will be full, and the Guru will
  106. ; awaken...
  107. ; These kind of mistakes are often pretty hard to trace :
  108. ; You dont see that there something wrong: the routine is indeed
  109. ; executed time after time, but in fact, you're about to crash !!
  110.  
  111. ; NOTE: the stack can be considered as a heap of notes. On each note
  112. ;    you can write something, then you put it on top of the heap.
  113. ;    if you take one from this heap, you take the one that is on
  114. ;    top, in other words: the one you put down the latest.
  115. ;    The computer does the same, so if you put something on the
  116. ;    stack, remember only to take it back when it's there.
  117. ;    This would be wrong, for example:
  118. ;
  119. ;        BSR routine
  120. ;        ...
  121. ;
  122. ;
  123. ;    routine:MOVEM.L d0-d7/a0-a6,-(a7)
  124. ;        RTS
  125. ;
  126. ; BSR causes the computer to save this point on the stack, to be
  127. ; able to jump back later...
  128. ; 'routine' puts values on the stack, using the MOVEM .. -(a7), and
  129. ; then tries to jump back from the subroutine. The last value on 
  130. ; the stack will however NOT be the address that was saved when
  131. ; jumping to the routine, but it will be one of the registers we 
  132. ; just saved. so we will jump to a completely unknown value, which
  133. ; will probably cause a GURU !!!
  134.  
  135.